// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "content/renderer/pepper/ppb_broker_impl.h"

#include "base/logging.h"
#include "content/common/frame_messages.h"
#include "content/common/view_messages.h"
#include "content/renderer/pepper/host_globals.h"
#include "content/renderer/pepper/pepper_broker.h"
#include "content/renderer/pepper/pepper_plugin_instance_impl.h"
#include "content/renderer/pepper/plugin_module.h"
#include "content/renderer/render_thread_impl.h"
#include "content/renderer/render_view_impl.h"
#include "ppapi/c/pp_errors.h"
#include "ppapi/shared_impl/platform_file.h"
#include "third_party/WebKit/public/web/WebDocument.h"
#include "third_party/WebKit/public/web/WebPluginContainer.h"

using ppapi::PlatformFileToInt;
using ppapi::TrackedCallback;
using ppapi::thunk::PPB_Broker_API;

namespace content {

// PPB_Broker_Impl ------------------------------------------------------

PPB_Broker_Impl::PPB_Broker_Impl(PP_Instance instance)
    : Resource(ppapi::OBJECT_IS_IMPL, instance)
    , broker_(NULL)
    , connect_callback_()
    , pipe_handle_(PlatformFileToInt(base::SyncSocket::kInvalidHandle))
    , routing_id_(RenderThreadImpl::current()->GenerateRoutingID())
{
    ChildThreadImpl::current()->GetRouter()->AddRoute(routing_id_, this);
}

PPB_Broker_Impl::~PPB_Broker_Impl()
{
    if (broker_) {
        broker_->Disconnect(this);
        broker_ = NULL;
    }

    // The plugin owns the handle.
    pipe_handle_ = PlatformFileToInt(base::SyncSocket::kInvalidHandle);
    ChildThreadImpl::current()->GetRouter()->RemoveRoute(routing_id_);
}

PPB_Broker_API* PPB_Broker_Impl::AsPPB_Broker_API() { return this; }

int32_t PPB_Broker_Impl::Connect(
    scoped_refptr<TrackedCallback> connect_callback)
{
    // TODO(ddorwin): Return PP_ERROR_FAILED if plugin is in-process.

    if (broker_) {
        // May only be called once.
        return PP_ERROR_FAILED;
    }

    PepperPluginInstanceImpl* plugin_instance = HostGlobals::Get()->GetInstance(pp_instance());
    if (!plugin_instance)
        return PP_ERROR_FAILED;
    PluginModule* module = plugin_instance->module();
    const base::FilePath& broker_path = module->path();

    // The callback must be populated now in case we are connected to the broker
    // and BrokerConnected is called before ConnectToBroker returns.
    // Because it must be created now, it must be aborted and cleared if
    // ConnectToBroker fails.
    connect_callback_ = connect_callback;

    broker_ = module->GetBroker();
    if (!broker_) {
        broker_ = new PepperBroker(module);

        // Have the browser start the broker process for us.
        RenderThreadImpl::current()->Send(
            new FrameHostMsg_OpenChannelToPpapiBroker(routing_id_, broker_path));
    }

    RenderThreadImpl::current()->Send(
        new ViewHostMsg_RequestPpapiBrokerPermission(
            plugin_instance->render_frame()->render_view()->GetRoutingID(),
            routing_id_,
            GetDocumentUrl(),
            broker_path));

    // Adds a reference, ensuring that the broker is not deleted when
    // |broker| goes out of scope.
    broker_->AddPendingConnect(this);

    return PP_OK_COMPLETIONPENDING;
}

int32_t PPB_Broker_Impl::GetHandle(int32_t* handle)
{
    if (pipe_handle_ == PlatformFileToInt(base::SyncSocket::kInvalidHandle))
        return PP_ERROR_FAILED; // Handle not set yet.
    *handle = pipe_handle_;
    return PP_OK;
}

GURL PPB_Broker_Impl::GetDocumentUrl()
{
    PepperPluginInstanceImpl* plugin_instance = HostGlobals::Get()->GetInstance(pp_instance());
    return plugin_instance->container()->document().url();
}

// Transfers ownership of the handle to the plugin.
void PPB_Broker_Impl::BrokerConnected(int32_t handle, int32_t result)
{
    DCHECK(pipe_handle_ == PlatformFileToInt(base::SyncSocket::kInvalidHandle));
    DCHECK(result == PP_OK || handle == PlatformFileToInt(base::SyncSocket::kInvalidHandle));

    pipe_handle_ = handle;

    // Synchronous calls are not supported.
    DCHECK(TrackedCallback::IsPending(connect_callback_));

    connect_callback_->Run(result);
}

bool PPB_Broker_Impl::OnMessageReceived(const IPC::Message& message)
{
    bool handled = true;
    IPC_BEGIN_MESSAGE_MAP(PPB_Broker_Impl, message)
    IPC_MESSAGE_HANDLER(ViewMsg_PpapiBrokerChannelCreated,
        OnPpapiBrokerChannelCreated)
    IPC_MESSAGE_HANDLER(ViewMsg_PpapiBrokerPermissionResult,
        OnPpapiBrokerPermissionResult)
    IPC_MESSAGE_UNHANDLED(handled = false)
    IPC_END_MESSAGE_MAP()
    return handled;
}

void PPB_Broker_Impl::OnPpapiBrokerChannelCreated(
    base::ProcessId broker_pid,
    const IPC::ChannelHandle& handle)
{
    broker_->OnBrokerChannelConnected(broker_pid, handle);
}

void PPB_Broker_Impl::OnPpapiBrokerPermissionResult(bool result)
{
    broker_->OnBrokerPermissionResult(this, result);
}

} // namespace content
